home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / UIFlow 1.0.1 / UIFlow Source / VSet2.0 / temp / vrw.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-12  |  18.5 KB  |  710 lines  |  [TEXT/????]
  1. /****************************************************************************e
  2. * 
  3. *              NCSA HDF Vset release 2.1
  4. *                    May 1991
  5. *
  6. * NCSA HDF Vset release 2.1 source code and documentation are in the public
  7. * domain.  Specifically, we give to the public domain all rights for future
  8. * licensing of the source code, all resale rights, and all publishing rights.
  9. * 
  10. * We ask, but do not require, that the following message be included in all
  11. * derived works:
  12. * 
  13. * Portions developed at the National Center for Supercomputing Applications at
  14. * the University of Illinois at Urbana-Champaign.
  15. * 
  16. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  17. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  18. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  19. * 
  20. ***************************************************************************** 
  21. * Likkai Ng NCSA May 1991
  22. *
  23. * vrw.c
  24. * Part of the HDF VSet interface.
  25. *
  26. ************************************************************************/
  27.  
  28. #include <stdio.h>
  29. #include "vg.h"
  30. /*
  31. USEFUL MACRO. Print an error message, then return  -1.
  32. */
  33.  
  34. /* ------------------------------------------------------------------------ */
  35.  
  36. /*
  37. the series of #defines below establishes the conversion routines
  38. to be used for a particular machine. For all machines, the 
  39. following 6 conversion routines are defined:
  40.  
  41.     FLOATtoIEEE     - machine float to IEEE float 
  42.     FLOATfromIEEE     - machine float from IEEE float    
  43.     INTtoIEEE         - machine integer to IEEE integer 
  44.     INTfromIEEE       - machine integer from IEEE integer 
  45.     CHARtoIEEE        - machine character to IEEE character 
  46.     CHARfromIEEE   - machine character from IEEE character 
  47.     LONGtoIEEE        - machine long to IEEE long 
  48.     LONGfromIEEE      - machine long from IEEE long 
  49. */
  50.  
  51. #ifdef CTSS 
  52. #define FLOATtoIEEE       crayFtoIEEE
  53. #define FLOATfromIEEE     crayFfromIEEE
  54. #define INTtoIEEE         inttoIEEE
  55. #define INTfromIEEE       intfromIEEE
  56. #define CHARtoIEEE         bytetoIEEE
  57. #define CHARfromIEEE       bytefromIEEE
  58. #define LONGtoIEEE         longtoIEEE
  59. #define LONGfromIEEE       longfromIEEE
  60. #endif CTSS 
  61.  
  62. #ifdef UNICOS
  63. #define FLOATtoIEEE       crayFtoIEEE
  64. #define FLOATfromIEEE     crayFfromIEEE
  65. #define INTtoIEEE         inttoIEEE
  66. #define INTfromIEEE       intfromIEEE
  67. #define CHARtoIEEE         bytetoIEEE
  68. #define CHARfromIEEE       bytefromIEEE
  69. #define LONGtoIEEE         longtoIEEE
  70. #define LONGfromIEEE       longfromIEEE
  71. #endif UNICOS
  72.  
  73. #ifdef VMS
  74. #define FLOATtoIEEE       vaxFtoIEEE
  75. #define FLOATfromIEEE     vaxFfromIEEE
  76. #define INTtoIEEE         inttoIEEE
  77. #define INTfromIEEE       intfromIEEE
  78. #define CHARtoIEEE         bytetoIEEE
  79. #define CHARfromIEEE       bytefromIEEE
  80. #define LONGtoIEEE         longtoIEEE
  81. #define LONGfromIEEE       longfromIEEE
  82. #endif VMS
  83.  
  84. #ifdef PC
  85. #define FLOATtoIEEE       floattoIEEE
  86. #define FLOATfromIEEE     floatfromIEEE
  87. #define INTtoIEEE         inttoIEEE
  88. #define INTfromIEEE       intfromIEEE
  89. #define CHARtoIEEE         bytetoIEEE
  90. #define CHARfromIEEE       bytefromIEEE
  91. #define LONGtoIEEE         longtoIEEE
  92. #define LONGfromIEEE       longfromIEEE
  93. #endif PC
  94.  
  95. #ifdef SUN
  96. #define FLOATtoIEEE       floattoIEEE
  97. #define FLOATfromIEEE     floatfromIEEE
  98. #define INTtoIEEE         inttoIEEE
  99. #define INTfromIEEE       intfromIEEE
  100. #define CHARtoIEEE         bytetoIEEE
  101. #define CHARfromIEEE       bytefromIEEE
  102. #define LONGtoIEEE         longtoIEEE
  103. #define LONGfromIEEE       longfromIEEE
  104. #endif SUN
  105.  
  106. #ifdef ALLIANT
  107. #define FLOATtoIEEE       floattoIEEE
  108. #define FLOATfromIEEE     floatfromIEEE
  109. #define INTtoIEEE         inttoIEEE
  110. #define INTfromIEEE       intfromIEEE
  111. #define CHARtoIEEE         bytetoIEEE
  112. #define CHARfromIEEE       bytefromIEEE
  113. #define LONGtoIEEE         longtoIEEE
  114. #define LONGfromIEEE       longfromIEEE
  115. #endif ALLIANT
  116.  
  117. #ifdef IRIS4
  118. #define FLOATtoIEEE       floattoIEEE
  119. #define FLOATfromIEEE     floatfromIEEE
  120. #define INTtoIEEE         inttoIEEE
  121. #define INTfromIEEE       intfromIEEE
  122. #define CHARtoIEEE         bytetoIEEE
  123. #define CHARfromIEEE       bytefromIEEE
  124. #define LONGtoIEEE         longtoIEEE
  125. #define LONGfromIEEE       longfromIEEE
  126. #endif IRIS4
  127.  
  128. #ifdef MAC
  129. #define FLOATtoIEEE       floattoIEEE
  130. #define FLOATfromIEEE     floatfromIEEE
  131. #define INTtoIEEE         inttoIEEE
  132. #define INTfromIEEE       intfromIEEE
  133. #define CHARtoIEEE         bytetoIEEE
  134. #define CHARfromIEEE       bytefromIEEE
  135. #define LONGtoIEEE         longtoIEEE
  136. #define LONGfromIEEE       longfromIEEE
  137. #endif MAC
  138.  
  139. /* ------------------------------------------------------------------------ */
  140. /*
  141.   The above 6 defined function entry-points are then stuffed
  142.   into 2 PRIVATE arrays of conversion pointers ie, (*convtoIEEE[])() and
  143.   (*convfromIEEE[])().
  144.  
  145.   Any conversion function in these arrays may be invoked by
  146.   indexing into the private arrays with one of the following:
  147.   LOCAL_NOTYPE,
  148.   LOCAL_CHARTYPE, 
  149.   LOCAL_INTTYPE,
  150.   LOCAL_FLOATTYPE 
  151.   LOCAL_LONGTYPE,
  152.  
  153.  */
  154.  
  155. extern int
  156.  
  157. DIRECTtoIEEE(), DIRECTfromIEEE(),
  158. CHARtoIEEE(),   CHARfromIEEE(), 
  159. INTtoIEEE(),    INTfromIEEE(), 
  160. LONGtoIEEE(),   LONGfromIEEE(), 
  161. FLOATtoIEEE(),  FLOATfromIEEE(),
  162. nolongfn;
  163.  
  164. PRIVATE int (*convtoIEEE[])()  = { 
  165.     DIRECTtoIEEE,  CHARtoIEEE,  INTtoIEEE,  FLOATtoIEEE, LONGtoIEEE };
  166.  
  167. PRIVATE int (*convfromIEEE[])()= { 
  168.     DIRECTfromIEEE,  CHARfromIEEE,  INTfromIEEE,  FLOATfromIEEE, LONGfromIEEE };
  169.  
  170. /* ------------------------------------------------------------------------ */
  171. /* 
  172.     VSseek
  173.  
  174.     Seeks to an element boundary within a vdata
  175.     Vdata must be attached with "r" access.
  176.     Specify eltpos = 0 for 1st element, 1 for 2nd element etc.
  177.     RETURNS -1 on error
  178.     RETURNS position of element seeked to (0 or a +ve integer)
  179.         (eg  returns 5 if seek to the 6th element, etc)
  180. */
  181.  
  182. PUBLIC int VSseek (vs, eltpos)         /*@-@*/
  183.  
  184. VDATA *vs;
  185. int32       eltpos;
  186. {
  187.     int32 offset, n;
  188.  
  189.     if (vs==NULL)          RTNEG("VSseek: err vs null");
  190.     if (vs->access !='r')  RTNEG("VSseek: err only read-only allowed");
  191.     if (eltpos < 0)        RTNEG("VSseek: err neg value");
  192.  
  193.     if (eltpos >= vs->nvertices ) RTNEG("VSseek: err over seek");
  194.  
  195.     vs->vpos = eltpos;
  196.  
  197.     /* do the actual access and seek.  is this redundant?  */
  198.     if(DFaccess(vs->f,VSDATATAG,vs->oref,"r") == -1){
  199.         sprintf(sjs,"@VSseek: access <%d/%d> gives D err=%d\n",
  200.             VSDATATAG, vs->oref,DFerror);
  201.         zj;
  202.     }
  203.  
  204.     offset  = vs->vpos * vs->wlist.ivsize;
  205.     n = DFseek(vs->f,offset);
  206.     if (n != offset ) {
  207.         sprintf(sjs,"@VSseek: seek to %d rets %d\n", n, offset);
  208.         zj;
  209.         return(n/vs->wlist.ivsize);
  210.     }
  211.     else
  212.         return(eltpos); /* ok */
  213.  
  214. } /* VSseek */
  215.  
  216. /* ------------------------------------------------------------------------ */
  217.  
  218. /*
  219.     VSread
  220.     Reads a specified number of elements' worth of data from a vdata.
  221.     Data will be returned to you interlaced in the way you specified.
  222.     RETURNS -1 if error
  223.     RETURNS the number of elements read (0 or a +ve integer).
  224. */
  225.  
  226. PUBLIC int VSread (vs, buf, nelt, interlace)    /*@-@*/
  227.  
  228. VDATA    *vs;
  229. int32       nelt;
  230. int        interlace;
  231. unsigned char    *buf;
  232. {
  233.     register int                 isize,esize,hsize;
  234.     register unsigned char  *b1,*b2;
  235.     int                 i,j, n, nv, offset, type;
  236.     VWRITELIST         *w;
  237.     VREADLIST          *r;
  238.     unsigned char  *tbuf;
  239.     int                 uvsize;             /* size of "element" as NEEDED by user */
  240.  
  241.     if(vs == NULL)                    RTNEG("r: vs null");
  242.     if(vs->access != 'r')       RTNEG("r: access is r");
  243.     if(vs->nvertices == 0)        RTNEG("r: vs has 0 vertices");
  244.     if (-1 == vexistvs(vs->f,vs->oref) )    RTNEG("w: vs not found");
  245.  
  246.     if (interlace != FULL_INTERLACE  && 
  247.         interlace != NO_INTERLACE )
  248.         RTNEG("bad interlace specified");
  249.  
  250.     w = &(vs->wlist);
  251.     r = &(vs->rlist);
  252.     hsize = vs->wlist.ivsize;         /* size as stored in HDF */
  253.  
  254.     /* alloc space (tbuf) for reading in the raw data from vdata */
  255.     tbuf = (unsigned char*) DFIgetspace ( nelt * hsize );
  256.     if (tbuf==NULL) RTNEG("r: space");
  257.  
  258.  
  259.     /* ================ start reading ============================== */
  260.     /* ================ start reading ============================== */
  261.     /* ================ start reading ============================== */
  262.  
  263.     /*
  264.                       Procedure: 
  265.                       first access the vdata,
  266.                    then seek to the place last read from.
  267.                    read the next elements from that place.
  268.                    update element pointer in vdata.
  269.    */
  270.  
  271.     if ( DFaccess (vs->f,VSDATATAG,vs->oref,"r") == -1){
  272.         sprintf(sjs,"@VR: access <%d/%d> gives D err=%d\n",
  273.             VSDATATAG, vs->oref,DFerror);
  274.         zj;
  275.     }
  276.  
  277.     j = vs->vpos * vs->wlist.ivsize;
  278.  
  279.     n = DFseek(vs->f,j);
  280.     if (vjv)   { 
  281.         sprintf(sjs,"VSREAD: seek to v#%d ie pos %d\n",vs->vpos,j);
  282.         zj; 
  283.     }
  284.     if (n!=j) { 
  285.         sprintf(sjs,"@VR: seek to %d rets %d\n", n, j);
  286.         zj; 
  287.     }
  288.  
  289.     nv = ( (nelt > vs->nvertices) ? vs->nvertices : nelt );
  290.  
  291.     n = DFread(vs->f,tbuf,nv * hsize);
  292.     if (vjv) { 
  293.         sprintf(sjs,"#vsread: DFREAD read %d bytes (%dx%d) from vs\n", 
  294.             n,nv,hsize);
  295.         zj;
  296.     }
  297.  
  298.     if ( nv != nelt ) {
  299.         sprintf(sjs,"@vsread:NOTE:nv=%d nelt=%d!!\n",nv,nelt);
  300.         zj;
  301.         vs->vpos += (n/vs->wlist.ivsize);
  302.     }
  303.     else 
  304.         vs->vpos +=nelt;
  305.  
  306.     /* ================ done reading =============================== */
  307.     /* ================ done reading =============================== */
  308.     /* ================ done reading =============================== */
  309.  
  310.  
  311.  
  312.     /* 
  313.         Now, convert and repack field(s) from tbuf into buf.    
  314.  
  315.         This section of the code deals with interlacing. In all cases
  316.         the items for each of the fields are converted and shuffled 
  317.         around from the internal buffer "tbuf" to the user's buffer 
  318.         "buf".  When all is done, the space in "tbuf" is freed.
  319.  
  320.         There are 5 cases :
  321.         (A) user=NO_INTERLACE   & vdata=FULL_INTERLACE) 
  322.           (B) user=NO_INTERLACE   & vdata=NO_INTERLACE) 
  323.           (C) user=FULL_INTERLACE & vdata=FULL_INTERLACE) 
  324.         (D) user=FULL_INTERLACE & vadat=NO_INTERLACE) 
  325.         (E) SPECIAL CASE when field has order>1. 
  326.  
  327.         Cases (A)-(D) handles multiple fields of order 1.
  328.         Case (E) handles one field of order>1. Interlace is
  329.         irrelevant in this case. The case where there are 
  330.         multiple fields of order>1 is prevented from
  331.         existing by VSsetfields explicitly checking for this.
  332.                 
  333.     */
  334.  
  335.     /* --------------------------------------------------------------------- */
  336.     /* CASE  (E): Special Case For one field with order >1 only */
  337.  
  338.     if (w->n == 1 && w->order[0] > 1) {
  339.         b1 = buf;
  340.         b2 = tbuf;
  341.         esize = w->esize[0];
  342.         isize = w->isize[0];
  343.         type = w->type[0];
  344.  
  345.         if (vjv) {
  346.             sprintf(sjs,"@VSREAD: SPECIAL order=%d esiz=%d isiz=%d nelt=%d vsize %d\n", w->order[0], esize, isize,
  347.                 nelt , hsize); 
  348.             zj;
  349.             sprintf(sjs,"@VSREAD: type is %d\n", type);
  350.             zj;
  351.         }
  352.  
  353.         (*convfromIEEE[type]) (b2, b1,
  354.             isize/w->order[0], 
  355.             esize/w->order[0],
  356.             w->order[0] * nelt);
  357.  
  358.     } /* case (e) */
  359.  
  360.     /* --------------------------------------------------------------------- */
  361.     /* CASE  (A):  user=none, vdata=full */
  362.  
  363.     else if (interlace==NO_INTERLACE && vs->interlace==FULL_INTERLACE) {
  364.         if (vjv) {
  365.             sprintf(sjs,"#R:  CASE  (A):  iu=none, iv=full \n"); 
  366.             zj;
  367.         }
  368.  
  369.         b1 = buf;
  370.         for (j=0;j<r->n;j++) {
  371.             i     = r->item[j];
  372.             b2    = tbuf + w->off[i];
  373.             type  = w->type[i];
  374.             esize = w->esize[i];
  375.  
  376.             (*convfromIEEE[type]) (b2, b1,
  377.                 hsize,
  378.                 esize,
  379.                 nelt);
  380.  
  381.             b1 += (nelt * esize);
  382.         }
  383.  
  384.     } /* case (a) */
  385.  
  386.     /* --------------------------------------------------------------------- */
  387.     /* CASE  (B):  user=none, vdata=none */
  388.     else if (interlace==NO_INTERLACE && vs->interlace==NO_INTERLACE) {
  389.         if (vjv) {
  390.             sprintf(sjs,"#R:  CASE  (B):  iu=none, iv=none\n"); 
  391.             zj;
  392.         }
  393.         b1 = buf;
  394.         for (j=0;j<r->n;j++) {
  395.             i     = r->item[j];
  396.             b2    = tbuf + w->off[i] * nelt;
  397.             type  = w->type[i];
  398.             esize = w->esize[i];
  399.             isize = w->isize[i];
  400.  
  401.             (*convfromIEEE[type]) (b2, b1,
  402.                 isize,
  403.                 esize,
  404.                 nelt);
  405.  
  406.             b1 += (nelt * esize);
  407.         }
  408.     } /* case (b) */
  409.  
  410.     /* --------------------------------------------------------------------- */
  411.     /* CASE  (C):  iu=full, iv=full */
  412.     else if (interlace==FULL_INTERLACE && vs->interlace==FULL_INTERLACE) {
  413.         if (vjv) {
  414.             sprintf(sjs,"#R:  CASE  (C):  iu=full, iv=full\n"); 
  415.             zj;
  416.         }
  417.  
  418.         for (uvsize=0, j=0;j<r->n;j++)
  419.             uvsize += w->esize[r->item[j]];
  420.  
  421.         for (offset=0,j=0;j<r->n;j++) {
  422.             i     = r->item[j];
  423.             b1    = buf + offset;
  424.             b2    = tbuf + w->off[i];
  425.             type  = w->type[r->item[j]];
  426.             esize = w->esize[i];
  427.             isize = w->isize[i];
  428.  
  429.             (*convfromIEEE[type]) (b2, b1,
  430.                 hsize,
  431.                 uvsize,
  432.                 nelt);
  433.             offset += esize;
  434.         }
  435.  
  436.     } /* case (c) */
  437.  
  438.  
  439.     /* --------------------------------------------------------------------- */
  440.     /* CASE  (D):  user=full, vdata=none */
  441.     else if(interlace==FULL_INTERLACE && vs->interlace==NO_INTERLACE) {
  442.         if (vjv) {
  443.             sprintf(sjs,"#R:  CASE  (D):  iu=full, iv=none\n"); 
  444.             zj;
  445.         }
  446.  
  447.         for (uvsize=0, j=0;j<r->n;j++)
  448.             uvsize += w->esize[r->item[j]];
  449.  
  450.         for (offset=0,j=0;j<r->n;j++) {
  451.             i     = r->item[j];
  452.             b1    = buf + offset;
  453.             b2    = tbuf + w->off[i] * nelt;
  454.             type  = w->type[i];
  455.             isize = w->isize[i];
  456.  
  457.             (*convfromIEEE[type]) (b2, b1,
  458.                 isize,
  459.                 uvsize,
  460.                 nelt);
  461.             offset +=isize;
  462.         }
  463.     } /* case (d) */
  464.  
  465.     DFIfreespace(tbuf);
  466.     return(n/hsize);
  467.  
  468. } /* VSread */
  469.  
  470. /* ------------------------------------------------------------------ */
  471. /*
  472.     VSwrite
  473.     Writes a specified number of elements' worth of data to a vdata.
  474.     You must specify how your data in your buffer is interlaced.
  475.     
  476.     RETURNS -1 if error
  477.     RETURNS the number of elements written (0 or a +ve integer).
  478. */
  479.  
  480.  
  481.  
  482. PUBLIC int VSwrite (vs, buf, nelt, interlace)   /*@-@*/
  483.  
  484. VDATA     *vs;
  485. int32        nelt;
  486. int        interlace;
  487. unsigned char *buf;
  488. {
  489.     register int                 isize,esize,hsize;
  490.     register unsigned char     *b1,*b2;
  491.     unsigned char                 *tbuf;
  492.     int             j,type, n,nv,offset;
  493.     VWRITELIST    *w;
  494.     int             uvsize;            /* size of "element" as needed by user */
  495.  
  496.     if (nelt <= 0)             RTNEG("w: 0 vertices");
  497.     if (vs == NULL)             RTNEG("w: vs null");
  498.     if (vs->access != 'w')     RTNEG("w: access is w");
  499.  
  500.     if ( -1 == vexistvs(vs->f,vs->oref) )    RTNEG("w: vs not found");
  501.     if (vs->wlist.ivsize == 0)    RTNEG("w: vsize 0. fields not set for write!");
  502.  
  503.     if (vs->nvertices != 0) { 
  504.         sprintf(sjs,"@VSwrite: append\n"); 
  505.         zj; 
  506.     }
  507.  
  508.     if (interlace != NO_INTERLACE && 
  509.         interlace != FULL_INTERLACE )
  510.         RTNEG("w: bad interlace");
  511.  
  512.     w = (VWRITELIST*) &vs->wlist;
  513.     hsize = w->ivsize;         /* as stored in HDF file */
  514.  
  515.     tbuf = (unsigned char*) DFIgetspace( nelt * hsize);
  516.     if (tbuf == NULL)  RTNEG("W: space ");
  517.  
  518.  
  519.     /* 
  520.         First, convert and repack field(s) from tbuf into buf.    
  521.  
  522.         This section of the code deals with interlacing. In all cases
  523.         the items for each of the fields are converted and shuffled 
  524.         around from the user's buffer "buf" to the internal's buffer 
  525.         "tbuf".  The data in "tbuf" is then written out to the vdata.
  526.         When all is done, the space in "tbuf" is freed.
  527.  
  528.         There are 5 cases :
  529.         (A) user=NO_INTERLACE   & vdata=FULL_INTERLACE) 
  530.       (B) user=NO_INTERLACE   & vdata=NO_INTERLACE) 
  531.       (C) user=FULL_INTERLACE & vdata=FULL_INTERLACE) 
  532.       (D) user=FULL_INTERLACE & vadat=NO_INTERLACE) 
  533.         (E) SPECIAL CASE when field has order>1. 
  534.  
  535.         Cases (A)-(D) handles multiple fields of order 1.
  536.         Case (E) handles one field of order>1. Interlace is
  537.         irrelevant in this case. The case where there are 
  538.         multiple fields of order>1 is prevented from
  539.         existing by VSsetfields explicitly checking for this.
  540.  
  541. /* --------------------------------------------------------------------- */
  542.     /* CASE  (E): Special Case For one field with order >1 only */
  543.  
  544.     if (w->n == 1 && w->order[0] > 1) {
  545.         b1    = buf;
  546.         b2    = tbuf;
  547.         esize = w->esize[0];
  548.         isize = w->isize[0];
  549.         type  = w->type[0];
  550.  
  551.         if (vjv) {
  552.             sprintf(sjs,"@VSWRITE: SPECIAL order=%d esiz=%d isiz=%d nelt=%d vsiz=%d\n", w->order[0], esize, isize,
  553.                 nelt, hsize); 
  554.             zj;
  555.             sprintf(sjs,"@VSWRITE: type = %d\n", type);
  556.             zj;
  557.         }
  558.  
  559.         (*convtoIEEE[type]) (b1, b2,
  560.             esize/w->order[0], 
  561.             isize/w->order[0],
  562.             w->order[0] * nelt);
  563.     } /* case (e) */
  564.  
  565.  
  566.     /* --------------------------------------------------------------------- */
  567.     /* CASE  (A):  user=none, vdata=full */
  568.     else if (interlace==NO_INTERLACE && vs->interlace==FULL_INTERLACE) {
  569.         if (vjv) {
  570.             sprintf(sjs,"#w:  CASE  (A):  iu=none, iv=full \n"); 
  571.             zj;
  572.         }
  573.  
  574.         b1 = buf;
  575.         for (j=0;j<w->n;j++) {
  576.             b2    = tbuf + w->off[j];
  577.             type  = w->type[j];
  578.             esize = w->esize[j];
  579.  
  580.             (*convtoIEEE[type]) (b1, b2,
  581.                 esize,
  582.                 hsize, nelt);
  583.  
  584.             b1 += (nelt * esize);
  585.         }
  586.  
  587.     } /* case (a) */
  588.  
  589.     /* --------------------------------------------------------------------- */
  590.     /* CASE  (B):  user=none, vdata=none */
  591.     else if (interlace==NO_INTERLACE && vs->interlace==NO_INTERLACE) {
  592.         if (vjv) {
  593.             sprintf(sjs,"#w:  CASE  (B):  iu=none, iv=none\n"); 
  594.             zj;
  595.         }
  596.  
  597.         b1 = buf;
  598.         for (j=0;j<w->n;j++) {
  599.             b2    = tbuf + w->off[j] * nelt;
  600.             type  = w->type[j];
  601.             esize = w->esize[j];
  602.             isize = w->isize[j];
  603.  
  604.             (*convtoIEEE[type]) (b1, b2,
  605.                 esize,
  606.                 isize,
  607.                 nelt);
  608.  
  609.             b1 += (nelt * esize);
  610.         }
  611.  
  612.     } /* case (b) */
  613.  
  614.     /* --------------------------------------------------------------------- */
  615.     /* CASE  (C):  user=full, vdata=full */
  616.     else if (interlace==FULL_INTERLACE && vs->interlace==FULL_INTERLACE) {
  617.         if (vjv) {
  618.             sprintf(sjs,"#w:  CASE  (C):  iu=full, iv=full\n"); 
  619.             zj;
  620.         }
  621.  
  622.         for (uvsize=0, j=0;j<w->n;j++)
  623.             uvsize += w->esize[j];
  624.  
  625.         for (offset=0,j=0;j<w->n;j++) {
  626.             b1    = buf + offset;
  627.             b2    = tbuf + w->off[j];
  628.             type  = w->type[j];
  629.             esize = w->esize[j];
  630.             isize = w->isize[j];
  631.  
  632.             (*convtoIEEE[type]) (b1, b2,
  633.                 uvsize,
  634.                 hsize,
  635.                 nelt);
  636.             offset += esize;
  637.         }
  638.  
  639.  
  640.     } /* case (c) */
  641.  
  642.     /* --------------------------------------------------------------------- */
  643.     /* CASE  (D):  user=full, vdata=none */
  644.     else if (interlace==FULL_INTERLACE && vs->interlace==NO_INTERLACE) {
  645.         if (vjv) {
  646.             sprintf(sjs,"#w:  CASE  (D):  iu=full, iv=none\n"); 
  647.             zj;
  648.         }
  649.  
  650.         for (uvsize=0, j=0;j<w->n;j++)
  651.             uvsize += w->esize[j];
  652.  
  653.         for (offset=0,j=0;j<w->n;j++) {
  654.             b1    = buf  + offset;
  655.             b2    = tbuf + w->off[j] * nelt;
  656.             type  = w->type[j];
  657.             isize = w->isize[j];
  658.             esize = w->esize[j];
  659.             (*convtoIEEE[type]) (b1, b2,
  660.                 uvsize,
  661.                 isize,
  662.                 nelt);
  663.             offset +=esize;
  664.         }
  665.     } /* case (d) */
  666.  
  667.  
  668.  
  669.     /* ================ start writing ============================== */
  670.     /* ================ start writing ============================== */
  671.     /* ================ start writing ============================== */
  672.  
  673.  
  674.     n = DFaccess (vs->f,VSDATATAG,vs->oref,"a");
  675.     if (n == -1){
  676.         sprintf(sjs,"@VSwrite: access err, stat=%d DFerr=%d\n",n,DFerror);
  677.         zj;
  678.         DFIfreespace(tbuf);
  679.         return(FAIL);
  680.     }
  681.  
  682.     n  = DFwrite (vs->f,tbuf,nelt * hsize);
  683.     nv = n/hsize;
  684.  
  685.     if (vjv) {
  686.         sprintf(sjs,"#vswrite: written %d bytes (%d x %d) to vs [%s]\n",
  687.             n,nv,hsize,vs->vsname);
  688.         zj;
  689.     }
  690.  
  691.     /* ================ done writing =============================== */
  692.     /* ================ done writing =============================== */
  693.     /* ================ done writing =============================== */
  694.  
  695.     if ( nv != nelt) {
  696.         sprintf(sjs,"@vswrite: NOTE: nv=%d nvertices=%d!!\n",nv,nelt);
  697.         zj;
  698.     }
  699.  
  700.     DFIfreespace(tbuf);
  701.     vs->nvertices += nv;
  702.  
  703.     vs->marked = 1;
  704.  
  705.     return(nv);
  706.  
  707. } /* VSwrite */
  708.  
  709. /* ------------------------------------------------------------------ */
  710.